import java.util.Arrays;
import java.util.HashMap;

/**
 * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 * <p>
 * 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
 * <p>
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/two-sum
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class SearchNumber {


    public static void main(String[] args) {
        int[] aaa = {1, 29, 8, 7, 6, 5, 4, 3};
        Solution solution = new Solution();

        int[] resut = solution.twoSum2(aaa, 30);

        for (int i : resut) {
            System.out.println(i);
        }
    }


    static class Solution {

        public int[] twoSum1(int[] nums, int target) {

            int[] result = new int[2];
            for (int i = 0; i < nums.length; i++) {
                for (int j = 1; j < nums.length; j++) {
                    if (target - nums[i] == nums[j]) {
                        result[result.length - 1] = i;
                        result[result.length - 1] = j;
                    }
                }
            }

            return result;
        }


        public int[] twoSum2(int[] nums, int target) {
            HashMap<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                map.put(nums[i], i);
            }
            int[] result = new int[2];
            map.forEach((k, v) -> {
                int complement = target - k;
                Integer comPosion = map.get(complement);
                if (map.containsKey(complement) && comPosion != v) {
                    result[0] = v;
                    result[1] = comPosion;
                }

            });
            return result;

        }

        public int[] twoSum3(int[] nums, int target) {
            HashMap<Integer, Integer> hashMap = new HashMap<>();
            int[] result = {-1, -1};
            for (int i = 0; i < nums.length; i++) {

                int item = nums[i];
                int value = target - item;
                if (hashMap.containsKey(value)) {

                    result[0] = hashMap.get(value);
                    result[1] = i;
                    return result;
                }

                hashMap.put(item, i);

            }

            return result;

        }


        /**
         * 冒泡排序
         */
        private void maoPao(int[] data) {

            boolean isChange = false;//如果没有交换过元素，则已经有序
            int k = data.length - 1;
            int pos = 0;
            for (int i = 0; i < data.length; i++) {

                pos = 0;

                for (int j = 0; j < k; j++) {
                    if (data[j + 1] - data[j] < 0) {

                        int temp = data[j];//较小的数
                        data[j] = data[j + 1];//较大的数
                        data[j + 1] = temp;//较小的数
                        isChange = true;

                        pos = j;//交换元素，记录最后一次交换的位置
                    }
                }
                k = pos;//下一次比较到记录位置即可
                if (isChange == false) {
                    //如果没有交换过元素，则已经有序
                    return;
                }


            }
        }


    }
}
